// hdu5794
// 题意：
// 给定一个n*m(<=10^18 * 10^18)的棋盘，有个马（按日走）初始在(1, 1)要到
// (n, m)，只能向右或者向下走日，棋盘上有r(<=100)个障碍物，问从(1, 1)
// 到(n, m)马不经过障碍物的路径条数。
//
// 题解：
// 首先要知道如果不考虑障碍物，马从(1, 1)到(n, m)的方案数，
// 考虑横纵坐标，一共是n+m-2个格子，所以马走的步数step=(n+m-2)/3。
// 然后每走一步，横纵坐标都至少会减1, 所以在step步之后，
// 横坐标剩余n-1-step, 纵坐标剩余m-1-step。那么接下来就是要选择马走的形态，
// 所以路径方案数是 C(step, n - 1 - step) 或者 C(step, m - 1 - step)。
//
// 然后我们考虑障碍物(x, y)，我们只需要按x坐标升序排序，x相等再按y升序。
// 然后用dp[i]表示从(1, 1)走到第i个障碍物位置不经过别的障碍物的方案数，
// 那么dp[i]=calc(xi, yi) - dp[j]*calc(xi - xj + 1, yi - yj + 1)。
// calc表示长为x，宽为y的矩形，从(1, 1)到(x, y)的路径方案数。
// 如果障碍点j在i的右边，那么跳过就行。
// 其实这有点补集转换的思想。
//
// 然后要求C(n, m) % mo, 这个可以用lucas定理，然后mo数比较小，可以实现
// 预处理出所有阶乘以及逆元，逆元可以用费马小定理算一个，然后O(n)递推。
//
// 要注意障碍物可能在(n, m)这个点。
//
// ml:run = $bin < input > output
// ml:ccf += -g
// ml:opt = 0
#include <iostream>
#include <algorithm>

using ll = long long;

struct data { ll x, y; };

bool operator<(data const& a, data const& b)
{
    return a.x < b.x  || (a.x == b.x && a.y < b.y);
}

int const maxn = 107;
ll const mo = 110119;
ll fact[mo + 7];
ll inverse[mo + 7];
data da[maxn];
ll dp[maxn];
ll n, m, r;

ll quick(ll a, ll b, ll mo)
{
    ll ret = 1;
    for (; b; a = (a * a) % mo, b /= 2)
        if (b & 1) ret = (ret * a) % mo;
    return ret;
}

void init()
{
    int n = mo - 1; fact[0] = 1;
    for (int i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % mo;
    inverse[n] = quick(fact[n], mo - 2, mo);
    for (int i = n - 1; i >= 0; i--)
        inverse[i] = (inverse[i + 1] * (i + 1)) % mo;
}

ll quickc(int n, int m, ll mo)
{
    return (((fact[n] * inverse[m]) % mo) * inverse[n - m]) % mo;
}

ll lucas(ll n, ll m, ll mo)
{
    ll ret = 1;
    while (n && m) {
        ll tn = n % mo, tm = m % mo;
        if (tn < tm) return 0;
        /* ret *= (fact[tn] * quick((fact[tm] * fact[tn - tm]) % mo, mo - 2, mo)) % mo; */
        ret *= quickc(tn, tm, mo);
        ret %= mo;
        n /= mo; m /=mo;
    }
    return ((ret % mo) + mo) % mo;
}

ll calc(ll n, ll m)
{
    if (n < m) std::swap(n, m);
    if (m < 0) return 0;
    if ((n + m - 2) % 3) return 0;
    ll tmp = (n + m - 2) / 3;
    if (tmp + 1 > m) return 0;
    return lucas(tmp, m - tmp - 1, mo);
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    init();
    for (int ti = 1; std::cin >> n >> m >> r; ti++) {
        std::cout << "Case #" << ti << ": ";
        bool ok = true;
        for (int i = 0; i < r; i++) {
            std::cin >> da[i].x >> da[i].y;
            if (da[i].x == n && da[i].y == m) ok = false;
        }
        if ((n + m - 2) % 3 != 0) ok = false;
        if (!ok) { std::cout << "0\n"; continue; }

        da[r++] = {n, m};
        std::sort(da, da + r);
        for (int i = 0; i < r; i++) {
            dp[i] = calc(da[i].x, da[i].y);
            for (int j = i - 1; j >= 0; j--) {
                dp[i] -= (dp[j] * calc(da[i].x - da[j].x + 1, da[i].y - da[j].y + 1)) % mo;
                dp[i] = ((dp[i] % mo) + mo) % mo;
            }
        }

        std::cout << dp[r - 1] << "\n";
    }
}

